package com.qlm.tools;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;


public class NumUtil {
	/**
	 * 生成固定数量的中奖二维码id
	 * 
	 * @param max 最大值
	 * @param min 最小值
	 * @param mun 生成多少个
	 * */
	public static List<Integer> getResult(Integer Max,Integer Min,Integer num){
		ArrayList<Integer> list = new ArrayList<Integer>();
		while(true){
			int n = (int) Math.round(Math.random()*(Max-Min)+Min);
			if (!list.contains(n)) {
				list.add(n);
			}
			if (list.size()==num)
				break;
		}
		return list;
		
	}
	/**
	 * excl表格  String 转long
	 * @author Yanleixin
	 * @param startCode 
	 * @return
	 * */
	public static Long returnCode(String startCode){
		long n = 10;
		double num = 0;
		try {
			String lowerCase = startCode.toLowerCase();
			int length = lowerCase.indexOf('e');
			if (length>0) {
				String s = (String) startCode.subSequence(length+1, startCode.length());
				int i = Integer.parseInt(s);
				if (i>1) {
					for (int j = 1; j < i; j++) {
						n=n*10;
					}
					/**
					 * 修改数据类型精度
					 * double*long
					 * 2015.12.8
					 * */
					num = Double.parseDouble(startCode.substring(0,length));
					BigDecimal bignum = new BigDecimal(Double.toString(num));
					BigDecimal bign = new BigDecimal(n);
					n = bignum.multiply(bign).longValue();
				}else{
					num = Double.parseDouble(startCode.substring(0,length));
					BigDecimal bignum = new BigDecimal(Double.toString(num));
					BigDecimal bign = new BigDecimal(n);
					n = bignum.multiply(bign).longValue();
				}
			}else{
				return Long.valueOf(startCode);
			}
		} catch (Exception e) {
			return Long.valueOf(startCode);
		}
		return n;
	}
	
	/** 
	 * 随机指定范围内N个不重复的数 
	 * 利用HashSet的特征，只能存放不同的值 
	 * @param min 指定范围最小值 
	 * @param max 指定范围最大值 
	 * @param n 随机数个数 
	 * @param HashSet<Integer> set 随机数结果集 
	 */  
//	   public static void randomSet(int min, int max, int n, List<QrcodeHb> set) {  
//		   int size = set.size();
//	       if (n > (max - min + 1) || max < min) {  
//	           return;  
//	       }  
//	       for (int i = 0; i < n; i++) {  
//	           // 调用Math.random()方法  
//	           int num = (int) (Math.random() * (max - min+1)) + min;  
//	           set.add(num);// 将不同的数存入HashSet中  
//	       }  
//	       int setSize = set.size()-size;  
//	       // 如果存入的数小于指定生成的个数，则调用递归再生成剩余个数的随机数，如此循环，直到达到指定大小  
//	       if (setSize < n) {  
//	        randomSet(min, max, n - setSize, set);// 递归  
//	       }  
//	   }  
	
	/**
	 * 依据条件数组及数量数组，获取均匀分布的中奖顺序
	 * 可配数量需大于中奖数量，可配数量越大，分布越均匀
	 * 概率小的条件先执行可保证分布均匀性
	 * @param start_id 起始编号
	 * @param end_id 结束编号
	 * @param arr 条件数组
	 * @param number 数量数组
	 * @return
	 */
	public static Map<String,List<Integer>> getRandomSeq(int start_id,int end_id, int[] arr, int[] number) {
		Map<String,List<Integer>> map = new LinkedHashMap<String, List<Integer>>();
		int num = end_id - start_id+1;
		if(num <= 0 || arr.length!=number.length || arr.length==0 || number.length==0){
			return null;
		}
		Set<Integer> set = new LinkedHashSet<Integer>();//存放所有序号
		Random r = new Random();
		for(int i=0; i<arr.length; i++){
			if(num <= number[i]){
				return null;
			}
			List<Integer> list = new ArrayList<Integer>();
			int size = (int)(num/number[i]);
			Integer a=null;
			do{
				a = r.nextInt(size)+1;
			}while(a==null && set.contains(a));
			set.add(a+start_id);
			
			for(int j=0;j<number[i];j++){
				int c = a+j*size;
				while(set.contains(c) && c>num){
					c++;
				}
				list.add(c+start_id);
				set.add(c+start_id);
			}
			map.put(arr[i]+"", list);
		}
		return map;
	}
	
	/**
	 * 获取1亿至10亿间的随机数
	 */
	public static Integer getRandomNum(int max,int min){
		Random r = new Random();
		Integer num = r.nextInt(max-min)+min;
		return num;
	}
	
}
